home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Libraries / CommToolbox classes / Sources / CTermPane.c < prev   
Text File  |  1993-03-06  |  23KB  |  1,175 lines
  1. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞
  2.  
  3.     CTermPane.c
  4.     
  5.     Commtoolbox terminal emulation class.
  6.     
  7.     SUPERCLASS = CPanorama.
  8.     
  9.     Copyright © 1992-93 Romain Vignes. All rights reserved.
  10.     
  11. ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  12.  
  13.  
  14. #include <CommResources.h>                        /* Apple includes */ 
  15.  
  16. #include <CBartender.h>                            /* TCL includes */
  17. #include <CClipboard.h>
  18. #include <CCluster.h>
  19. #include <CError.h>
  20. #include <Commands.h>
  21. #include <Constants.h>
  22. #include <CWindow.h>
  23. #include <Global.h>
  24. #include <LongQD.h>
  25. #include <TBUtilities.h>
  26. #include <TCLUtilities.h>
  27.  
  28. #include "CTermPane.h"                            /* Other includes */
  29.  
  30.  
  31. /* Constants & Macros */
  32.  
  33. #define TERM_STR_RES_ID        2200    /* Emulation messages resource ID */
  34.  
  35. #define NO_TOOL_STR_INDEX    1        /* No terminal tool */
  36. #define BAD_TOOL_STR_INDEX    2        /* Bad terminal tool */
  37. #define NO_REC_STR_INDEX    3        /* Terminal record allocation error */
  38. #define CHOOSE_STR_INDEX    4        /* Tool setup error */
  39.  
  40. #define H_CHOOSE_POS        10        /* Setup dialog position */
  41. #define V_CHOOSE_POS        40
  42.  
  43. #define SPACE                0x20    /* Space char */
  44. #define TAB                    0x09    /* Tab char */
  45.  
  46. #define CHAR_DELAY_TICKS    15
  47.  
  48. #define RESET_ALRT_ID        2200
  49.  
  50.  
  51. /* Application globals */
  52.  
  53. extern CBartender    *gBartender;
  54. extern CClipboard    *gClipboard;
  55. extern CError        *gError;
  56. extern EventRecord  gLastMouseUp;
  57.  
  58.  
  59. /* Class Variables Initialization */
  60.  
  61. CCluster    *CTermPane::cTermList = NULL;
  62.  
  63.  
  64.  
  65. /*
  66.  * cTermIdle
  67.  *
  68.  * Idle time for each terminal object
  69.  *
  70.  *
  71.  */
  72.  
  73.          /* Idle routine for each terminal object */
  74.  
  75.         static void    Term_Idle(CTermPane *theTerm)
  76.         {
  77.             theTerm->DoIdle();
  78.         }
  79.  
  80.  
  81. void CTermPane::cTermIdle(void)
  82. {
  83.     if (cTermList != NULL)        /* List exists ? */
  84.         cTermList->DoForEach((EachFunc) Term_Idle);
  85. }    
  86.  
  87.  
  88. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  89.  
  90. /*
  91.  * cInitManager
  92.  *
  93.  * Terminal Manager Initialization
  94.  *
  95.  */
  96.  
  97. void CTermPane::cInitManager(void)
  98. {
  99.     InitTM();
  100. }    
  101.  
  102.  
  103. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  104.  
  105. /*
  106.  * cGetTMVersion
  107.  *
  108.  * return the version of the Terminal Manager
  109.  *
  110.  */
  111.  
  112. short CTermPane::cGetTMVersion(void)
  113. {
  114.     return TMGetTMVersion();
  115. }    
  116.  
  117.  
  118. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  119.  
  120. /*
  121.  * cCheckToolName
  122.  *
  123.  * Existence tool checking
  124.  *
  125.  * toolName:    name of the tool
  126.  *
  127.  * Return tmGenericError if the tool is not found
  128.  *
  129.  */
  130.  
  131. OSErr CTermPane::cCheckToolName(Str63 toolName)
  132. {
  133.     return(TMGetProcID(toolName));
  134. }    
  135.  
  136.  
  137. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  138.  
  139. /*
  140.  * cTestToolMenu
  141.  *
  142.  * Test if the selected menu belongs to a terminal tool
  143.  *
  144.  * theMenu:    selected menu ID
  145.  * theItem:    selected item ID
  146.  *
  147.  * Return TRUE if the menu is a terminal tool menu
  148.  */
  149.  
  150.  
  151.          /* Test routine */
  152.  
  153.         static Boolean TermMenuTest(CTermPane *theTerm)
  154.         {
  155.             return theTerm->active;
  156.         }
  157.  
  158.  
  159. Boolean CTermPane::cTestToolMenu(short theMenu, short theItem)
  160. {
  161.     CTermPane    *current;
  162.     
  163.     if (cTermList == NULL)
  164.         return FALSE;
  165.     else    {
  166.         current = (CTermPane *) cTermList->FindItem((TestFunc) TermMenuTest);
  167.         
  168.         if (current == NULL)
  169.             return FALSE;
  170.         else
  171.             return current->DoMenu(theMenu,theItem);
  172.     }
  173. }    
  174.  
  175.  
  176. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  177.  
  178. /*
  179.  * cTestToolEvent
  180.  *
  181.  * Test if the event is related to a terminal tool
  182.  *
  183.  * macEvent:    pointer on the event record
  184.  * theWindow:    pointer on the window record
  185.  *
  186.  * Return TRUE if the event is a terminal event
  187.  */
  188.  
  189. typedef struct    {
  190.     EventRecord    *theEvent;
  191.     WindowPtr    theWindow;
  192.     Boolean        isToolEvent;
  193. } TestParamRec;
  194.  
  195.  
  196.          /* Test routine */
  197.  
  198.         static void TermEvtTest(CTermPane *theTerm,TestParamRec *params)
  199.         {
  200.             if (params->isToolEvent == FALSE)
  201.                 params->isToolEvent = theTerm->DoEvent(params->theEvent,
  202.                     params->theWindow);
  203.         }
  204.  
  205.  
  206. Boolean CTermPane::cTestToolEvent(EventRecord *macEvent,WindowPtr theWindow)
  207. {
  208.     TestParamRec params;
  209.     
  210.     params.theEvent = macEvent;
  211.     params.theWindow = theWindow;
  212.     params.isToolEvent = FALSE;
  213.     
  214.     if (cTermList == NULL)
  215.         return FALSE;
  216.     else    {
  217.         cTermList->DoForEach1((EachFunc1) TermEvtTest,(long) ¶ms);
  218.         
  219.         return params.isToolEvent;
  220.     }
  221. }    
  222.  
  223.  
  224. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  225.  
  226. /*
  227.  * ITermPane
  228.  * 
  229.  * Terminal pane object Initialization
  230.  *
  231.  * anEnclosure:        its enclosure view
  232.  * aSupervisor:        its supervisor in the chain of command
  233.  * toolName:        Terminal tool name ("" -> default tool)
  234.  * flags(TM):        How to use the tool
  235.  * sendProc(TM):    Pointer on the chars sending procedure
  236.  * cacheProc(TM):    Pointer on the cach managing procedure
  237.  * breakProc(TM):    Pointer on the BREAK signal sending procedure
  238.  * clickLoop(TM):    Pointer on the clics handling sending procedure
  239.  * environsProc(TM):Pointer on the environnement description procedure
  240.  * refCon(TM):        undefined (application can use it)
  241.  * userData(TM):    undefined (application can use it)
  242.  *
  243.  * Parameters followed by TM are exactly matching the ones used for the 
  244.  * terminal record creation.
  245.  *
  246.  */
  247.  
  248. void CTermPane::ITermPane(CView *anEnclosure, CBureaucrat *aSupervisor,
  249.                             Str63    toolName,TMFlags flags,ProcPtr sendProc,
  250.                             ProcPtr cacheProc,ProcPtr breakProc,
  251.                             ProcPtr clickLoop,ProcPtr environsProc,long refCon,
  252.                             long userData)
  253.  
  254. {
  255.     LongRect        lRect,newBounds;
  256.     Rect            termRect,viewRect;
  257.     OSErr            theErr;
  258.     short            toolProcID;
  259.     WindowPtr        owner;
  260.     Boolean            savedAlloc;
  261.     TermHandle        hTerm;
  262.     Str63            tName;
  263.     TermEnvironRec    theEnvirons;
  264.     
  265.     CPanorama::IPanorama(anEnclosure, aSupervisor,0,0,0,0,
  266.                             sizELASTIC, sizELASTIC); /* Initialize 
  267.                                                         its superclass */
  268.                             
  269.     termRect.top = 0;                    /* visible terminal rect */
  270.     termRect.left = 0;
  271.     termRect.bottom = 0;
  272.     termRect.right = 0;
  273.     
  274.     owner = (WindowPtr) this->GetMacPort();        /* Window port */
  275.     
  276.     if (toolName[0] == 0)    {        /* Default tool ? */
  277.     
  278.         theErr = CRMGetIndToolName(classTM,1,tName);
  279.         if ((theErr != noErr) || (tName[0] == 0))         /* No tool */
  280.             Failure(tmNoTools,SpecifyMsg(TERM_STR_RES_ID,NO_TOOL_STR_INDEX));
  281.  
  282.         toolProcID = TMGetProcID(tName);            /* Default tool ID */
  283.     }
  284.     else
  285.         toolProcID = TMGetProcID(toolName);            /* Chosen tool ID */
  286.     
  287.     if (toolProcID == tmGenericError)            /* Bad tool */
  288.             Failure(tmNoTools,SpecifyMsg(TERM_STR_RES_ID,BAD_TOOL_STR_INDEX));
  289.         
  290.     savedAlloc = SetAllocation(kAllocCanFail);
  291.         
  292.     hTerm = TMNew(&termRect,&termRect,flags,toolProcID,owner,
  293.                     sendProc,cacheProc,breakProc,clickLoop,environsProc,
  294.                     refCon,userData);
  295.                     
  296.     SetAllocation(savedAlloc);
  297.     
  298.     FailNIL(hTerm);                /* Terminal record created ? */
  299.  
  300.     MoveHHi((Handle)hTerm);        /* Heap fragmentation… */
  301.     
  302.     this->itsTerm = hTerm;
  303.         
  304.     this->changedConfig();    /* Configuration update */
  305.     
  306.     this->SetWantsClicks(TRUE);        
  307.     
  308.     this->SetCanBeGopher(TRUE);        
  309.     
  310.     if (cTermList == NULL)    {        /* First Terminal Object ? */
  311.         cTermList = new(CCluster);
  312.         cTermList->ICluster();
  313.     }
  314.     
  315.     cTermList->Add(this);            /* Terminal addition */
  316. }
  317.  
  318.  
  319.  
  320.  
  321. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  322.  
  323. /*
  324.  * Dispose
  325.  *
  326.  * Terminal pane object disposal
  327.  *
  328.  */
  329.  
  330. void CTermPane::Dispose(void)
  331. {
  332.     ASSERT(cTermList != NULL);
  333.     
  334.     cTermList->Remove(this);        /* Dispose of the terminal */
  335.     
  336.     if (cTermList->IsEmpty())
  337.         ForgetObject(cTermList);    /* Dispose of the cluster */
  338.  
  339.     TMDispose(itsTerm);                /* Terminal record removal */
  340.     itsTerm = NULL;
  341.     
  342.     inherited::Dispose();        /* Pass message to its superclass */
  343. }
  344.  
  345.  
  346. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  347.  
  348. /*
  349.  * Draw
  350.  *
  351.  * Terminal pane drawing
  352.  *
  353.  * area:    Pointer on the region to be updated
  354.  *
  355.  */
  356.  
  357. void CTermPane::Draw(Rect *area)
  358. {
  359.     RgnHandle    updateRgn;
  360.     
  361.     Prepare();
  362.     
  363.     updateRgn = NewRgn();
  364.     FailNIL(updateRgn);
  365.     
  366.     RectRgn(updateRgn,area);        /* Transform rect into region */
  367.         
  368.     TMUpdate(itsTerm,updateRgn);
  369.         
  370.     DisposeRgn(updateRgn);
  371. }
  372.  
  373.  
  374. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  375.  
  376. /*
  377.  * DoCommand
  378.  *
  379.  * Terminal pane related commands handling
  380.  *
  381.  * theCommand:    Command to be executed
  382.  *
  383.  */
  384.  
  385. void CTermPane::DoCommand(long theCommand)
  386. {    
  387.     Handle        selectionHdl;
  388.     ResType        selectionType;
  389.     short        scrapLength,i;
  390.     EventRecord    theEvent;
  391.     
  392.     switch (theCommand) {        
  393.     
  394.         case cmdTermChoose:        /* Terminal tool setup */
  395.             this->TermChoose();
  396.             break;
  397.     
  398.         case cmdTermClear:        /* Screen clearing */
  399.             this->TermClear();
  400.             break;
  401.     
  402.         case cmdTermReset:        /* Terminal reset */
  403.             this->Reset();
  404.             break;
  405.     
  406.         case cmdCopy:            /* Copy */
  407.             selectionHdl = NewHandle(0);
  408.             TMGetSelect(itsTerm,selectionHdl,&selectionType);
  409.             
  410.             gClipboard->EmptyScrap();
  411.             gClipboard->PutData(selectionType,selectionHdl);
  412.             
  413.             DisposHandle(selectionHdl);
  414.             
  415.             break;
  416.     
  417.         case cmdTabCopy:        /* Table copy */
  418.             this->DoTabCopy();
  419.             break;
  420.             
  421.         case cmdPaste:            /* Paste */
  422.         
  423.             theEvent.what = keyDown;
  424.             
  425.             gClipboard->GetData('TEXT',&selectionHdl);
  426.         
  427.             scrapLength = gClipboard->DataSize('TEXT');
  428.             
  429.             for (i = 0;i < scrapLength;i ++)    {    /* For each char… */
  430.                 theEvent.message = (*selectionHdl)[i];
  431.                 theEvent.modifiers = 0;
  432.                 TMKey(itsTerm,&theEvent);
  433.             }
  434.             DisposHandle(selectionHdl);
  435.             
  436.             break;
  437.             
  438.         case cmdSelectAll:        /* Complete pane selection */
  439.             this->DoSelectAll();
  440.             break;
  441.     
  442.         default:
  443.             inherited::DoCommand(theCommand);
  444.             break;
  445.     }
  446. }
  447.  
  448.  
  449. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  450.  
  451. /*
  452.  * UpdateMenus
  453.  *
  454.  * Terminal tool menus updating
  455.  *
  456.  */
  457.  
  458. void CTermPane::UpdateMenus(void)
  459. {
  460.     Rect        nullRect;
  461.     SignedByte    savedState;
  462.     
  463.     savedState = HGetState(itsTerm);
  464.     HLock(itsTerm);
  465.     
  466.     inherited::UpdateMenus();            /* Pass message to its superclass */
  467.     
  468.     gBartender->EnableCmd(cmdSelectAll);    /* Complete selection */
  469.     
  470.     gBartender->EnableCmd(cmdTermChoose);    /* Terminal tool setup */
  471.  
  472.     gBartender->EnableCmd(cmdTermClear);    /* Screen clearing */
  473.  
  474.     gBartender->EnableCmd(cmdTermReset);    /* Terminal reset */
  475.     
  476.     SetRect(&nullRect,0,0,0,0);
  477.     
  478.     if (!EqualRect(&nullRect,&(((*itsTerm)->selection).selRect)))    {
  479.         gBartender->EnableCmd(cmdCopy);    /* Copier */
  480.         
  481.         if (((*itsTerm)->selType == selTextNormal) ||
  482.                 ((*itsTerm)->selType == selTextBoxed))
  483.             gBartender->EnableCmd(cmdTabCopy);    /* Table copy */
  484.         
  485.     }
  486.         
  487.     if (gClipboard->DataSize('TEXT') > 0)        /* Paste */
  488.         gBartender->EnableCmd(cmdPaste);
  489.         
  490.     HSetState(itsTerm,savedState);
  491. }
  492.  
  493.  
  494. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  495.  
  496. /*
  497.  * TermChoose
  498.  *
  499.  * Terminal tool setup
  500.  *
  501.  */
  502.  
  503. void CTermPane::TermChoose(void)
  504. {
  505.     short        retCode;
  506.     Point        where;
  507.     TermHandle    hTerm;
  508.     
  509.     hTerm = this->itsTerm;
  510.     HUnlock((Handle)hTerm);
  511.     
  512.     SetPt(&where,H_CHOOSE_POS,V_CHOOSE_POS);    /* Dialog position */
  513.                                                 
  514.     retCode = TMChoose(&hTerm,where,NULL);
  515.     
  516.     HLock((Handle)hTerm);
  517.     this->itsTerm = hTerm;
  518.  
  519.     switch (retCode)    {        
  520.         case chooseCancel:        /* Canceled setup */
  521.             break;
  522.             
  523.         case chooseOKMinor:        /* Same tool, changed config */
  524.         case chooseOKMajor:        /* Changed tool */
  525.         
  526.             this->changedConfig();    
  527.         
  528.             TMActivate(itsTerm,TRUE);
  529.             
  530.             itsSupervisor->Notify(NULL);     /* Notify document… */
  531.             
  532.             break;
  533.             
  534.         default:                /* Unknown code (error) */
  535.             FailOSErr(retCode);
  536.             break;    
  537.     }
  538. }
  539.  
  540.  
  541. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  542.  
  543. /*
  544.  * DoIdle
  545.  * 
  546.  * Application idle time
  547.  *
  548.  */
  549.  
  550. void CTermPane::DoIdle(void)
  551. {    
  552.     Prepare();
  553.     
  554.     TMIdle(itsTerm);
  555. }
  556.  
  557.     
  558. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  559.  
  560. /*
  561.  * AdjustCursor
  562.  *
  563.  * Cursor shape update
  564.  *
  565.  * where:        cursor position
  566.  * mouseRgn:    mouse region
  567.  *
  568.  */
  569.  
  570. void    CTermPane::AdjustCursor(Point where,RgnHandle mouseRgn)    
  571. {
  572.     /* The cursor shape is updated by the tool during the idle time */
  573.  
  574. }
  575.  
  576.  
  577. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  578.  
  579. /*
  580.  * Activate
  581.  *
  582.  * Terminal pane activating
  583.  *
  584.  */
  585.  
  586. void CTermPane::Activate(void)
  587. {
  588.     inherited::Activate();        /* Pass message to its superclass    */
  589.     
  590.     Prepare();
  591.  
  592.     TMActivate(itsTerm,TRUE);        /* Tool activation */
  593. }    
  594.  
  595.  
  596. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  597.  
  598. /*
  599.  * Deactivate
  600.  *
  601.  * Terminal pane deactivation
  602.  *
  603.  */
  604.  
  605. void CTermPane::Deactivate(void)
  606. {
  607.     Prepare();
  608.  
  609.     TMActivate(itsTerm,FALSE);        /* tool deactivation */
  610.     
  611.     inherited::Deactivate();        /* Pass message to its superclass */
  612. }    
  613.  
  614.  
  615. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  616.  
  617. /*
  618.  * Mouse clic in the terminal pane
  619.  *
  620.  * hitPt:            Click position
  621.  * modifierKeys:    Keyboard stat
  622.  * when:            click instant
  623.  *
  624.  */
  625.  
  626. void CTermPane::DoClick(Point hitPt,short modifierKeys,long when)
  627. {
  628.     EventRecord    theEvent;
  629.     
  630.     theEvent.what = mouseDown;        
  631.     theEvent.where = hitPt;
  632.     LocalToGlobal(&theEvent.where);        /* Conversion */
  633.     theEvent.modifiers = modifierKeys;
  634.     theEvent.when = when;
  635.     
  636.     TMClick(itsTerm,&theEvent);        /* Tool handles clicks… */
  637.     
  638.     gLastMouseUp.what = mouseUp;    /* MouseUp… simulation */
  639.     gLastMouseUp.when = TickCount();
  640.     gLastMouseUp.where = hitPt;
  641.     LocalToGlobal( &gLastMouseUp.where);    /* Conversion */
  642.     gLastMouseUp.modifiers = modifierKeys;
  643.  
  644. }
  645.  
  646.  
  647. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  648.  
  649. /*
  650.  * ResizeFrame
  651.  *
  652.  * Changing of the terminal pane size
  653.  *
  654.  * delta:    updates rect
  655.  *
  656.  */
  657.  
  658. void CTermPane::ResizeFrame(Rect *delta)
  659. {
  660.     Rect    newTermRect;
  661.     
  662.     inherited::ResizeFrame(delta);            /* Pass message to its superclass */
  663.     
  664.     FrameToWindR(&frame,&newTermRect);        /* Visible region */
  665.     
  666.     TMResize(itsTerm,&newTermRect);         /* tool handles resizing… */
  667. }
  668.  
  669. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  670.  
  671. /*
  672.  * DoKeyDown
  673.  *
  674.  * Keyboard handling
  675.  *
  676.  * theChar:        Typed char
  677.  * keyCode:        Code of the corresponding key
  678.  * macEvent:    Pointer on the related event
  679.  *
  680.  */
  681.  
  682. void CTermPane::DoKeyDown(char theChar,Byte keyCode,EventRecord    *macEvent)
  683. {
  684.     TMKey(itsTerm,macEvent);        /* Tool handles keys… */
  685.     
  686. }    
  687.  
  688.  
  689. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  690.  
  691. /*
  692.  * TypeChar
  693.  *
  694.  * Type simulation
  695.  *
  696.  * theChar:        char to be typed
  697.  *
  698.  */
  699.  
  700. void CTermPane::TypeChar(unsigned char theChar)
  701. {
  702.     EventRecord    theEvent;
  703.     long        finalTicks;
  704.     
  705.     theEvent.what = keyDown;
  706.     theEvent.message = theChar;
  707.     theEvent.modifiers = 0;
  708.     
  709.     Delay(CHAR_DELAY_TICKS,&finalTicks);
  710.     
  711.     this->DoKeyDown(theChar,0,&theEvent);
  712.     
  713. }    
  714.  
  715.  
  716. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  717.  
  718. /*
  719.  * DoAutoKey
  720.  *
  721.  * Key repetition
  722.  *
  723.  * theChar:        typed char
  724.  * keyCode:        code of the related code
  725.  * macEvent:    Pointer on the corresponding event
  726.  *
  727.  */
  728.  
  729. void CTermPane::DoAutoKey(char theChar,Byte keyCode,EventRecord    *macEvent)
  730. {
  731.     this->DoKeyDown(theChar,keyCode,macEvent);    
  732. }    
  733.  
  734.  
  735. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  736.  
  737. /*
  738.  * SetConfig
  739.  *
  740.  * Terminal tool configuration
  741.  *
  742.  * theConfig:    configuration C string
  743.  *
  744.  * Return:        Negative value: error (-1 -> unknown)
  745.  *                Positive value: Parser stop index
  746.  *                tmNoErr if all is OK
  747.  *
  748.  */
  749.  
  750. short CTermPane::SetConfig(char *theConfig)
  751. {
  752.     short retCode;
  753.     
  754.     retCode = TMSetConfig(itsTerm,theConfig);
  755.     
  756.     this->changedConfig();    /* Config update */
  757.     
  758.     return retCode;
  759. }    
  760.  
  761.  
  762. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  763.  
  764. /*
  765.  * GetToolName
  766.  *
  767.  * Return the name of the current tool
  768.  *
  769.  * toolName:    name of the current tool (pascal string)
  770.  *
  771.  */
  772.  
  773. void CTermPane::GetToolName(Str63 toolName)
  774. {
  775.     SignedByte    savedState;
  776.     
  777.     savedState = HGetState(itsTerm);
  778.     HLock(itsTerm);
  779.     
  780.     TMGetToolName((*itsTerm)->procID,toolName);
  781.     
  782.     HSetState(itsTerm, savedState);
  783. }    
  784.  
  785.  
  786. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  787.  
  788. /*
  789.  * GetConfig
  790.  *
  791.  * Return the configuration string of the current tool
  792.  *
  793.  * Reeturn a pointer on the C string
  794.  *
  795.  */
  796.  
  797. Ptr CTermPane::GetConfig(void)
  798. {
  799.     return(TMGetConfig(itsTerm));
  800. }    
  801.  
  802.  
  803. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  804.  
  805. /*
  806.  * DoMenu
  807.  *
  808.  * Terminal tool menus handling
  809.  *
  810.  * theMenu:    selected menu
  811.  * theItem:    selected item
  812.  *
  813.  * Return TRUE if the menu belongs to the tool
  814.  *
  815.  */
  816.  
  817. Boolean CTermPane::DoMenu(short theMenu,short theItem)
  818. {
  819.     return(TMMenu(itsTerm,theMenu,theItem));
  820. }    
  821.  
  822.  
  823. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  824.  
  825. /*
  826.  * DoEvent
  827.  *
  828.  * Terminal tool related events
  829.  *
  830.  * theEvent:    Pointeur on the event
  831.  * theWindow:    Window associated with the event
  832.  *
  833.  * Return TRUE if it is a tool event
  834.  *
  835.  */
  836.  
  837. Boolean CTermPane::DoEvent(EventRecord *theEvent,WindowPtr theWindow)
  838. {
  839.     Boolean        isToolEvent;
  840.     TermHandle    theTerm;
  841.     
  842.     isToolEvent = FALSE;
  843.     
  844.     theTerm = (TermHandle) GetWRefCon(theWindow);
  845.     
  846.     if (theTerm == itsTerm)    {            /* Tool window ? */
  847.         TMEvent(itsTerm,theEvent);
  848.         isToolEvent = TRUE;
  849.     }
  850.     
  851.     return isToolEvent;
  852. }    
  853.  
  854.  
  855. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  856.  
  857. /*
  858.  * GetTermHandle
  859.  *
  860.  * Return a Handle on the current terminal record
  861.  *
  862.  * Return the Handle
  863.  *
  864.  */
  865.  
  866. TermHandle CTermPane::GetTermHandle(void)
  867. {
  868.     return(itsTerm);
  869. }    
  870.  
  871.  
  872. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  873.  
  874. /*
  875.  * DoStream
  876.  *
  877.  * Received data handling
  878.  *
  879.  * buffer:        Receiving buffer
  880.  * buffSize:    buffer size
  881.  * flags:        end of message
  882.  *
  883.  * Return the nb of chars handled
  884.  *
  885.  */
  886.  
  887. long CTermPane::DoStream(Ptr buffer,long buffSize,CMFlags flags)
  888. {
  889.     Prepare();
  890.  
  891.     return (TMStream(itsTerm,buffer,buffSize,flags));
  892. }    
  893.  
  894.  
  895. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  896.  
  897. /*
  898.  * TermClear
  899.  *
  900.  * Terminal pane clearing
  901.  *
  902.  */
  903.  
  904. void CTermPane::TermClear(void)
  905. {
  906.     Prepare();
  907.  
  908.     TMClear(itsTerm);
  909. }    
  910.  
  911.  
  912. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  913.  
  914. /*
  915.  * Reset
  916.  *
  917.  * Terminal reset
  918.  *
  919.  */
  920.  
  921. void CTermPane::Reset(void)
  922. {
  923.     short    response;
  924.     
  925.     PositionDialog('ALRT', RESET_ALRT_ID);
  926.     
  927.     InitCursor();
  928.     
  929.     response = Alert(RESET_ALRT_ID, NULL);
  930.         
  931.     if (response == answerNO)    {
  932.         Prepare();
  933.     
  934.         TMReset(itsTerm);
  935.         
  936.         this->changedConfig();    /* Configuration update */
  937.     }
  938.  
  939. }    
  940.  
  941.  
  942. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  943.  
  944. /*
  945.  * DoTabCopy
  946.  *
  947.  * Table copy
  948.  *
  949.  */
  950.  
  951. void CTermPane::DoTabCopy(void)
  952. {
  953.     Handle            selectionHdl,scrapHdl;
  954.     ResType            selectionType;
  955.     long            selectionLength,scrapLength;
  956.     short            i,scrapIndex,spacePending;
  957.     unsigned char    theChar;
  958.     
  959.     selectionHdl = NewHandle(0);
  960.     selectionLength = TMGetSelect(itsTerm,selectionHdl,&selectionType);
  961.     
  962.     scrapHdl = NewHandle(selectionLength);
  963.     scrapLength = selectionLength;
  964.     
  965.     spacePending = 0;
  966.     
  967.     scrapIndex = 0;
  968.     
  969.     for (i = 0;i < selectionLength;i ++)    {    /* For each char… */
  970.     
  971.         theChar = (*selectionHdl)[i];
  972.         
  973.         if (theChar == SPACE)        /* Space char ? */
  974.             spacePending ++;
  975.         else    {
  976.             
  977.             if (spacePending > 1)    {    /* More than one space ? */
  978.                 (*scrapHdl)[scrapIndex] = TAB;
  979.                 
  980.                 scrapIndex ++;
  981.                 scrapLength -= (spacePending - 1);
  982.                 
  983.                 (*scrapHdl)[scrapIndex] = theChar;
  984.                 scrapIndex ++;
  985.                 spacePending = 0;
  986.             }
  987.             else if (spacePending == 1)    {    /* Exactly one space ? */
  988.                 (*scrapHdl)[scrapIndex] = TAB;
  989.                 scrapIndex ++;
  990.                 (*scrapHdl)[scrapIndex] = theChar;
  991.                 scrapIndex ++;
  992.                 spacePending = 0;
  993.             }
  994.             else    {
  995.                 (*scrapHdl)[scrapIndex] = theChar;
  996.                 scrapIndex ++;
  997.             }                        
  998.         }
  999.     }
  1000.     
  1001.     SetHandleSize(scrapHdl,scrapLength);
  1002.     
  1003.     gClipboard->EmptyScrap();
  1004.     gClipboard->PutData(selectionType,scrapHdl);
  1005.     
  1006.     DisposHandle(selectionHdl);
  1007.     DisposHandle(scrapHdl);
  1008. }    
  1009.  
  1010.  
  1011. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  1012.  
  1013. /*
  1014.  * GetExtent
  1015.  *
  1016.  * Return the size (in char rows and columns) of the terminal pane
  1017.  *
  1018.  * theHExtent:    Nb of columns
  1019.  * theVExtent:    Nb of rows
  1020.  *
  1021.  */
  1022.  
  1023. void CTermPane::GetExtent(long *theHExtent,long *theVExtent)
  1024. {
  1025.     TermEnvironRec theEnvirons;
  1026.     
  1027.     this->GetEnvirons(&theEnvirons);
  1028.  
  1029.     *theHExtent = theEnvirons.textCols;
  1030.     *theVExtent = theEnvirons.textRows;
  1031. }
  1032.  
  1033.  
  1034. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  1035.  
  1036. /*
  1037.  * GetEnvirons
  1038.  *
  1039.  * Terminal parameters
  1040.  *
  1041.  * theEnvirons:        Pointer on the environment record
  1042.  *
  1043.  * Return an error code
  1044.  *
  1045.  */
  1046.  
  1047. OSErr CTermPane::GetEnvirons(TermEnvironRec *theEnvirons)
  1048. {
  1049.     theEnvirons->version = curTermEnvRecVers;/* Record version */
  1050.  
  1051.     return (TMGetTermEnvirons(itsTerm,theEnvirons));    
  1052. }    
  1053.  
  1054.  
  1055. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  1056.  
  1057. /*
  1058.  * GetLine
  1059.  *
  1060.  * Content of a terminal screen line
  1061.  *
  1062.  * lineNo:        line number
  1063.  * theTermData:    Pointer on the content of the line
  1064.  *
  1065.  * Renturn an error code
  1066.  *
  1067.  */
  1068.  
  1069. void CTermPane::GetLine(short lineNo,TermDataBlock *theTermData)
  1070. {
  1071.     theTermData->theData = NewHandleCanFail(0);
  1072.     
  1073.     TMGetLine(itsTerm,lineNo,theTermData);    
  1074. }    
  1075.  
  1076.  
  1077. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  1078.  
  1079. /*
  1080.  * Scroll
  1081.  *
  1082.  * Terminal pane scrolling
  1083.  *
  1084.  * hDelta:    Horizontal scrolling
  1085.  * vDelta:    vertical scrolling
  1086.  * redraw:    flag of redrawing
  1087.  *
  1088.  */
  1089.  
  1090. void CTermPane::Scroll(long hDelta,long vDelta,Boolean redraw)
  1091. {
  1092.     long                hPixels,vPixels;
  1093.     
  1094.     hPixels = hDelta * hScale;
  1095.     vPixels = vDelta * vScale;
  1096.     
  1097.     if ((Abs(hPixels) < width) && (Abs(vPixels) < height))    {
  1098.         Prepare();    
  1099.         TMScroll(itsTerm,-(hDelta * hScale),-(vDelta * vScale));
  1100.     }
  1101.     else
  1102.         Refresh();
  1103.  
  1104.     position.h += hDelta;
  1105.     position.v += vDelta;
  1106.  
  1107.     if (redraw)
  1108.         ((CWindow *) (((WindowPeek) macPort)->refCon))->Update();
  1109. }
  1110.  
  1111.  
  1112. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  1113.  
  1114. /*
  1115.  * changedConfig
  1116.  *
  1117.  * Terminal tool configuration update
  1118.  *
  1119.  */
  1120.  
  1121. void CTermPane::changedConfig(void)
  1122. {
  1123.     TermEnvironRec    theEnvirons;
  1124.     Rect            viewRect;
  1125.     LongRect        newBounds;
  1126.     SignedByte        savedState;
  1127.     
  1128.     savedState = HGetState(itsTerm);
  1129.     HLock(itsTerm);
  1130.     
  1131.     QDToLongRect(&((*itsTerm)->viewRect),&newBounds);    /* New dimensions */
  1132.     OffsetLongRect(&newBounds,-(newBounds.left),-(newBounds.top));
  1133.     this->SetBounds(&newBounds);
  1134.     
  1135.     this->GetEnvirons(&theEnvirons);                    /* Environment */
  1136.     
  1137.     hScale = theEnvirons.cellSize.h;                    /* Chars size */
  1138.     vScale = theEnvirons.cellSize.v;
  1139.  
  1140.     BroadcastChange(termSizeChangedInd, NULL);
  1141.     
  1142.     HSetState(itsTerm,savedState);
  1143. }    
  1144.  
  1145.  
  1146. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  1147.  
  1148. /*
  1149.  * DoSelectAll
  1150.  *
  1151.  * Complete selection
  1152.  *
  1153.  */
  1154.  
  1155. void CTermPane::DoSelectAll(void)
  1156. {
  1157.     TermEnvironRec    theEnvirons;
  1158.     TMSelection        newSelection;
  1159.     TMSelTypes        newSelType;
  1160.     
  1161.     Prepare();
  1162.     
  1163.     this->GetEnvirons(&theEnvirons);        /* Environment */
  1164.     
  1165.     SetRect(&(newSelection.selRect),1,1,theEnvirons.textCols,
  1166.         theEnvirons.textRows);
  1167.     
  1168.     newSelType = selTextNormal;
  1169.     
  1170.     TMSetSelection(itsTerm,&newSelection,newSelType);
  1171. }    
  1172.  
  1173.  
  1174. /* ∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞∞ */
  1175.